package com.hzit.manager.service.impl;

import java.util.List;
import java.util.stream.Collectors;

import com.hzit.manager.entity.SpecGroup;
import com.hzit.manager.mapper.SpecificationOptionMapper;
import com.hzit.manager.service.ISpecificationOptionService;
import com.ruoyi.system.api.domain.Specification;
import com.ruoyi.system.api.domain.SpecificationOption;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.hzit.manager.mapper.SpecificationMapper;
import com.hzit.manager.service.ISpecificationService;

/**
 * 规格管理Service业务层处理
 * 
 * @author hbxfwf
 * @date 2024-03-07
 */
@Service
public class SpecificationServiceImpl implements ISpecificationService 
{
    @Autowired
    private SpecificationMapper specificationMapper;
    @Autowired
    private ISpecificationOptionService specificationOptionService;
    @Autowired
    private SpecificationOptionMapper specificationOptionMapper;

    /**
     * 查询规格管理
     * 
     * @param id 规格管理主键
     * @return 规格管理
     */
    @Override
    public Specification selectSpecificationById(Long id)
    {
        return specificationMapper.selectSpecificationById(id);
    }

    /**
     * 查询规格管理列表
     * 
     * @param specification 规格管理
     * @return 规格管理
     */
    @Override
    public List<Specification> selectSpecificationList(Specification specification)
    {
        return specificationMapper.selectSpecificationList(specification);
    }

    /**
     * 新增规格管理
     * 
     * @param specification 规格管理
     * @return 结果
     */
    @Override
    public int insertSpecification(Specification specification)
    {
        return specificationMapper.insertSpecification(specification);
    }

    /**
     * 修改规格管理
     * 
     * @param specification 规格管理
     * @return 结果
     */
    @Override
    public int updateSpecification(Specification specification)
    {
        return specificationMapper.updateSpecification(specification);
    }

    /**
     * 批量删除规格管理
     * 
     * @param ids 需要删除的规格管理主键
     * @return 结果
     */
    @Override
    public int deleteSpecificationByIds(Long[] ids)
    {
        return specificationMapper.deleteSpecificationByIds(ids);
    }

    /**
     * 删除规格管理信息
     * 
     * @param id 规格管理主键
     * @return 结果
     */
    @Override
    public int deleteSpecificationById(Long id)
    {
        return specificationMapper.deleteSpecificationById(id);
    }

    // 添加规格及规格选项
	@Override
	public int addSpec(SpecGroup specGroup) {
        //1. 添加规格
        //1.1 得到规格
        Specification spec = specGroup.getSpec();
        //1.2 添加规格,如何保证添加完成后，可以得到当前插入的规格的主键呢？在mybagtis中进行如下配置：
        /*
           <insert id="insertSpecification" parameterType="Specification" useGeneratedKeys="true" keyProperty="id">
           其中useGeneratedKeys=true,代表使用自动生成的主键，keyProperty='id',代表将生成的主键赋值给id属性字段！
         */
        int rs1 = this.insertSpecification(spec);
        //1.3 添加规格选项
        List<SpecificationOption> options = specGroup.getOptions();
        int rs = 0;
        if(rs1 > 0){
            for (SpecificationOption option : options) {
                //1.3.1 绑定关联的外键
                option.setSpecId(specGroup.getSpec().getId());
                //1.3.2 添加规格选项
                rs = specificationOptionService.insertSpecificationOption(option);
            }
        }
        return rs;
	}

	// 根据规格id，查询出规格及规格选项的组合对象
    @Override
    public SpecGroup selectSpecGroupById(Long id) {
        SpecGroup specGroup = new SpecGroup();
        //1. 查询出规格
        Specification specification = this.selectSpecificationById(id);
        //2. 再根据规格id，查询出规格选项
        //2.1 封装查询条件（作为规格选项表的外键字段）
        SpecificationOption option = new SpecificationOption();
        option.setSpecId(id);
        List<SpecificationOption> options = this.specificationOptionService.selectSpecificationOptionList(option);
        //3. 为规格组合对象赋值
        specGroup.setOptions(options);
        specGroup.setSpec(specification);
        return specGroup;
    }
    // 修改规格及规格选项
    @Override
    public int updateSpec(SpecGroup specGroup) {
        //1. 修改规格表
        Specification spec = specGroup.getSpec();
        this.updateSpecification(spec);
        //2. 根据规格的id，在规格选项表中删除对应的规格选项
        //2.1 找到要删除的规格选项的列表
        SpecificationOption option = new SpecificationOption();
        option.setSpecId(spec.getId());
        List<SpecificationOption> options = specificationOptionService.selectSpecificationOptionList(option);
        //2.2 规格规格选项列表找出对应的id列表
        List<Long> ids = options.stream().map(m -> m.getId()).collect(Collectors.toList());
        //2.3 将集合转换为数组
        Long[] optionsIds = ids.toArray(new Long[ids.size()]);
        //2.4 返回执行的条数
        int i = this.specificationOptionService.deleteSpecificationOptionByIds(optionsIds);
        //2.5 再重新添加到规格选项列表中
        if(i > 0){
            for (SpecificationOption groupOption : specGroup.getOptions()) {
                groupOption.setSpecId(spec.getId());
                i = specificationOptionService.insertSpecificationOption(groupOption);
            }
        }
        return i;
    }
}
